home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 4 / The 640 Meg Shareware Studio CD-ROM Volume IV (Data Express)(1994).ISO / wp / ehp10.zip / AUS_1.C next >
C/C++ Source or Header  |  1993-06-19  |  28KB  |  673 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  aus_1.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - ueberschreiben (Neuen Text in altes Fenster)  */
  7. /*              - do_win_zu (Fenster schliessen)                */
  8. /*              - laden (Datei laden und Fenster oeffnen)       */
  9. /*              - do_schreib_file (Datei abspeichern)           */
  10. /*              - do_help (Hilfstexte an/aus)                   */
  11. /*              - do_refresh (refreshe Bildschirm)              */
  12. /*              - do_z_runter (Text und Cursor eine Z. runter)  */
  13. /*              - do_z_hoch (Text und Cursor eine Zeile hoch)   */
  14. /*              - do_z_mitte (aktuelle Zeile in Fenstermitte)   */
  15. /*              - do_z_unten (aktuelle Zeile an Fensterende)    */
  16. /*              - do_z_oben (aktuelle Zeile an Fensteranfang)   */
  17. /*              - do_bol (gehe an Zeilenanfang)                 */
  18. /*              - do_eol (gehe an Zeilenende)                   */
  19. /*              - do_halfup (gehe halbe Seite hoch)             */
  20. /*              - do_halfdn (gehe halbe Seite runter)           */
  21. /*              - do_delete (loesche aktuelles Zeichen)         */
  22. /*              - do_backspace (loesche Zeichen links)          */
  23. /*              - do_home (Cursor an Bildschirmanfang)          */
  24. /*              - do_nothome (Cursor an Bildschirmende)         */
  25. /*              - do_underline (Underlinemodus togglen)         */
  26. /*              - do_insovr (Schreibmodus togglen)              */
  27. /****************************************************************/
  28.  
  29. #define aus1_def
  30. #include "defs.h"
  31.  
  32. extern char backupflag,highblockflag,clear_buff,bufflag;
  33. extern int schreib_file(),to_shell();
  34. extern short int letter,lastcode,aktcode,taste();
  35. extern int save_delline(),rest_delline();
  36. extern int tst_overlap(),do_find(),do_replace(),do_repfr();
  37. extern char bufflag,*loadfile;
  38. extern bzeil_typ *save_normal(),*save_rechteck();
  39. extern block_typ global_block,*dup_block();
  40. extern puff_typ macro[],puff_feld[];
  41. extern int ks_index;
  42. extern short int *keystack,*e_keystack,newwgetch();
  43. extern WINDOW *status;
  44. extern marker_typ marker[];
  45. void do_refresh();
  46.  
  47. /* *** interne Daten und Initialisierung *** */
  48. char *on_off[] = 
  49. #ifdef GERMAN
  50.          {"ausgeschaltet.","eingeschaltet."}; /* Hilfstexte */
  51. #else
  52.          {"turned off.","turned on."}; /* Hilfstexte */
  53. #endif
  54.                  /* fuer Togglen der globalen Flags */
  55. char helpflag=TRUE;              /* Flag: Hilfstexte anzeigen       */
  56.  
  57. /****************************************************************************
  58. *
  59. *  Funktion       Neuen Text in altes Fenster (ueberschreiben)
  60. *  --------
  61. *
  62. *  Beschreibung : Fragt den User nach dem Filenamen der Datei und liest,
  63. *                 falls die Datei geladen werden konnte, diese ein.
  64. *                 Gelang dies nicht, wird das Fenster geschlossen.
  65. *
  66. *****************************************************************************/
  67.  
  68. void ueberschreiben()
  69. {
  70.   /* *** interne Daten und Initialisierung *** */
  71.   char    name[61],                 /* Name der zu ladenden Datei */
  72.       dummy[MAXLENGTH+1];       /* String fuer Fehlermeldung  */
  73.   int     wn = akt_winp->wini,      /* Variable fuer aktuelle Fensternummer */
  74.       ws;                       /* Fensternummer des Fensters, in dem Datei
  75.                        eventuell schon enthalten ist */
  76.  
  77.   if(!akt_winp->changeflag || ja_nein(PROMPT_WARNLOAD))
  78.   {
  79.     print_stat(PROMPT_FILENAME);
  80.     read_stat(name,60,GS_ANY); /* Filename nach name einlesen (alle Zeichen erlaubt) */
  81.     clear_stat();              /* Kommandozeile wieder loeschen */
  82.     if(!name[0])               /* Falls Leereingabe, Funktion beenden */
  83.     {
  84.       setz_cursor(W_AKT);
  85.       return;
  86.     }
  87.     bufflag = FALSE;            /* Pufferinhalt verwerfen */
  88.     akt_winp->filename[0]='\0'; /* leere Filenamen gibt es nicht */
  89.     free_text();                /* also wird aktuelles Fenster durch sw_name */
  90.     if (sw_name(name))          /* keinesfalls gefunden. sw_name checkt, */
  91.     {                           /* ob Datei in einem Fenster vorhanden */
  92.       sprintf(dummy,PROMPT_ALRDYLDD, akt_winp->wini);
  93.       if (!ja_nein(dummy))      /* Eingabe J/N, ob trotzdem ueberladen */
  94.       {
  95.     ws = akt_winp->wini;    /* Nummer des jetzt aktuellen Fensters merken */
  96.     make_akt_win(wn);       /* Zum alten Fenster gehen */
  97.     werase(akt_winp->winp); /* Fenster auf Bildschirm loeschen */
  98.     delwin(akt_winp->winp); /* Altes Fenster mit Curses loeschen */
  99.     gb_win_frei();          /* Window aus Liste auskoppeln */
  100.     make_akt_win(ws);       /* Wieder zum gefundenen Fenster gehen */
  101.     do_refresh();           /* Jetzt aktuellen Bildschirm zeichnen */
  102.     return;
  103.       }
  104.       else                      /* Wenn trotzdem überladen werden soll, */
  105.     make_akt_win(wn);       /* dann wieder zum alten Fenster gehen  */
  106.     }
  107.     line_free(akt_winp->filename); /* Filenamen deallokieren */
  108.     akt_winp->filename = save_text (name); /* Speicher fuer Filenamen holen */
  109.                        /* und Filename merken */
  110.     if (!lies_file ())          /* Datei einlesen. Falls das nicht klappt, */
  111.     {
  112.       werase(akt_winp->winp);   /* Fenster auf Bildschirm loeschen */
  113.       delwin(akt_winp->winp);   /* Fenster freigeben */
  114.       gb_win_frei ();           /* und aus Liste auskoppeln */
  115.       if(akt_winp->next == akt_winp)    /* kein Fenster mehr ? */
  116.       {
  117.     write_config();         /* Dann Config-File schreiben */
  118.     ende(0, TRUE);          /* und Programm beenden */
  119.       }
  120.       do_refresh();             /* Sonst kompletten Schirm neu aufbauen */
  121.     }
  122.     else                /* laden funktionierte */
  123.     {
  124.       akt_winp->ws_line = akt_winp->ws_col = 0; /* Erste Zeile und Spalte zeigen */
  125.       akt_winp->textcol = akt_winp->screencol = 0; /* Cursor nach oben links */
  126.       akt_winp->block.s_line = akt_winp->block.e_line = -1; /* kein Block markiert */
  127.       sw_ohne_refresh(W_AKT);                        /* Fenster darstellen */
  128.     }
  129.   }
  130.   setz_cursor(W_AKT);                /* Cursor plazieren und refresh ausfuehren */
  131. }
  132.  
  133. /****************************************************************************
  134. *
  135. *  Funktion       Fenster schliessen (do_win_zu)
  136. *  --------
  137. *
  138. *  Parameter    : wait_mouse:
  139. *                 Typ         : char
  140. *                 Wertebereich: TRUE, FALSE
  141. *                 Bedeutung   : Rufe im Falle, daß das zu schließende
  142. *                               Fenster das letzte offene war, ende()
  143. *                               mit wait_mouse als 2. Parameter auf.
  144. *
  145. *  Beschreibung : Nach einer Rueckfrage wird ggf. der dem Fenster assoziierte
  146. *                 Text freigegeben und das Fenster geschlossen.
  147. *
  148. *****************************************************************************/
  149.  
  150. void do_win_zu(wait_mouse)
  151. char wait_mouse;
  152. {
  153.   if(!akt_winp->changeflag ||     /* Hat sich Text nicht geaendert ? */
  154.      (akt_winp->changeflag &&     /* oder falls doch, will der User abbrechen ? */
  155.      ja_nein(PROMPT_WARNCLOSE)))
  156.   {
  157.     bufflag = FALSE;              /* Pufferinhalt verwerfen */
  158.     free_text();                  /* Text des aktuellen Fensters freigeben */
  159.     werase(akt_winp->winp);       /* Fenster fuer Curses loeschen */
  160.     delwin(akt_winp->winp);
  161.     gb_win_frei();                /* Fenster aus Liste auskoppeln */
  162.     if(akt_winp->next == akt_winp)      /* wenn keine Textfiles mehr, */
  163.     {
  164.       write_config();                   /* Config-File schreiben und Editor */
  165.       ende(0, wait_mouse);              /* beenden */
  166.     }
  167.     do_refresh();                       /* Sonst ganzen Schirm neu aufbauen */
  168.   }
  169.   setz_cursor(W_AKT);             /* und Cursor an richtige Position */
  170. }
  171.  
  172. /****************************************************************************
  173. *
  174. *  Funktion       laden (laden)
  175. *  --------
  176. *
  177. *  Ergebnis     : TRUE, falls File geladen werden konnte, sonst FALSE
  178. *  Beschreibung : Fragt den User nach dem Filenamen der Datei.
  179. *                 Falls schon ein Fenster mit dieser Datei existiert, wird
  180. *                 der User gefragt, ob wirklich neu geladen werden soll.
  181. *                 Wenn ja, dann oeffnet die Funktion, falls die Datei
  182. *                 geladen werden konnte, dafuer ein Fenster.
  183. *
  184. *****************************************************************************/
  185.  
  186. int laden()
  187. {
  188.   /* *** interne Daten und Initialisierung *** */
  189.   char    name[61],            /* Name der zu ladenden Datei */
  190.       dummy[MAXLENGTH+1];  /* String fuer Fehlermeldung */
  191.   int     wn = akt_winp->wini; /* Nummer des aktuellen Fensters */
  192.       /* um entscheiden zu koennen, ob Fenster neu gezeichnet werden muss */
  193.  
  194.   check_buff();                 /* Puffer evtl. zurueckschreiben */
  195.   print_stat(PROMPT_FILENAME);
  196.   read_stat(name,60,GS_ANY);    /* Filenamen einlesen (max. 60 zeichen) */
  197.   clear_stat();                 /* Kommandozeile wieder loeschen */
  198.   if(!name[0])                  /* Abbruch, falls leerer Name */
  199.   {
  200.     setz_cursor(W_AKT);
  201.     return (FALSE);
  202.   }
  203.   rahmen(W_NOTAKT); /* Rahmen "unhighlighten", damit falls anderes Fenster */
  204.   kopf(W_NOTAKT);   /* zum aktiven wird, nicht 2 gehighlightet */
  205.   if(akt_winp->next != akt_winp) /* Schon ein Fenster auf ? */
  206.     wrefresh(akt_winp->winp);
  207.   if (sw_name(name))            /* Versuchen, ein Fenster mit diesem Datei- */
  208.   {                             /* namen zu finden */
  209.     sprintf(dummy,PROMPT_ALRDYLDD,akt_winp->wini);
  210.     if (!ja_nein(dummy))        /* Falls gefunden, fragen, ob trotzdem neu laden */
  211.     {
  212.       show_win(W_AKT);           /* Falls nein, gefundenes Fenster zeichnen */
  213.       return (TRUE);
  214.     }
  215.   }
  216.   if (koppel_win())             /* Neues Fenster in Fensterliste einhaengen */
  217.   {                             /* Falls das klappt, Speicherplatz fuer File- */
  218.     akt_winp->filename = save_text (name); /* namen holen und merken */
  219.     if (!lies_file())           /* Datei einlesen */
  220.     {                           /* klappt das nicht, neu eingehaengtes Fenster */
  221.       gb_win_frei();            /* wieder auskoppeln */
  222.       rahmen(W_AKT);            /* Altes Fenster wieder optisch aktivieren */
  223.       setz_cursor(W_AKT);
  224.       return(FALSE);
  225.     }
  226.     open_window();              /* Klappte Einlesen, dann Fenster auf Schirm */
  227.     return(TRUE);               /* oeffnen, Koordinaten initialisieren usw. */
  228.   }
  229.   if(wn != akt_winp->wini)      /* Falls das aktuelle Fenster ein anderes ist */
  230.     show_win(W_AKT);             /* als vorher, dann neu zeichnen */
  231.   print_err(PROMPT_NOWINDOW); /* Falls koppel_win nicht klappte, Error */
  232.   return(FALSE);
  233. }
  234.  
  235. /*****************************************************************************
  236. *
  237. *  Funktion       Datei abspeichern (do_schreib_file)
  238. *  --------
  239. *
  240. *  Beschreibung : Die Datei im aktuellen Fenster wird mit der Funktion
  241. *                 schreib_file abgespeichert. Danach wird die Funktion
  242. *                 setz_cursor aufgerufen, damit in der unteren Rahmenzeile
  243. *                 der Text GEAENDERT verschwindet.
  244. *
  245. *****************************************************************************/
  246.  
  247. void do_schreib_file()
  248. {
  249.   schreib_file(); /* Aktuellen Text abspeichern */
  250.   setz_cursor(W_AKT);  /* Cursor wieder an richtige Stelle */
  251. }
  252.  
  253. /*****************************************************************************
  254. *
  255. *  Funktion       Hilfstexte an/aus (do_help)
  256. *  --------
  257. *
  258. *  Beschreibung : Die Hilfstextoption wird an- bzw. ausgeschaltet
  259. *
  260. *****************************************************************************/
  261.  
  262. void do_help()
  263. {
  264.   print_stat(PROMPT_HELPTEXT); /* Wenn helpflag TRUE ist, wird "eingeschaltet" */
  265.   print_stat(on_off[helpflag ^= TRUE]); /* ausgegeben, sonst "ausgeschaltet" */
  266.   sleep(2); /* 2 Sekunden warten, damit User die Meldung lesen kann. */
  267.   clear_stat();  /* Statuszeile wieder loeschen */
  268.   setz_cursor(W_AKT); /* und Cursor wieder an richtige Position */
  269. }
  270.  
  271. /*****************************************************************************
  272. *
  273. *  Funktion       refreshe Bildschirm (do_refresh)
  274. *  --------
  275. *
  276. *  Beschreibung : Der Bildschirm wird geloescht, alle Fenster, Rahmen und
  277. *                 Kopfzeilen neu gezeichnet und danach setz_cursor() aufge-
  278. *                 rufen.
  279. *
  280. *****************************************************************************/
  281.  
  282. void do_refresh()
  283. {
  284.   /* *** interne Daten und Initialisierung *** */
  285.   win_typ *oldwin = akt_winp; /* Zeiger auf Fenster, das bei Aufruf der */
  286.                   /* Funktion aktuell war. */
  287.  
  288.   check_buff();         /* Evtl. Pufferinhalt in Text schreiben */
  289.   werase(curscr);       /* Gesamten Bildschirm loeschen */
  290.   for(akt_winp=akt_winp->next->next; akt_winp != oldwin->next; akt_winp=akt_winp->next)
  291.   { /* Alle Fenster durchlaufen */
  292.     sw_ohne_refresh(akt_winp == oldwin ? W_AKT : W_NOTAKT); /* Fensterinhalt neu ausgeben */
  293.     kopf(akt_winp == oldwin ? W_AKT : W_NOTAKT); /* Kopf des Fensters ausgeben */
  294. #ifdef OWN_CURSES
  295.     wnoutrefresh(akt_winp->winp); /* Fensterinhalt anzeigen */
  296. #else
  297.     wrefresh(akt_winp->winp);
  298. #endif
  299.   } /* noch nicht in physikalischen Bildschirm uebertragen */
  300.   akt_winp = oldwin; /* Das Fester, das vorher aktuelle war, wieder zum */
  301.   pos_cursor();      /* aktuellen machen, Cursor positionieren */
  302. #ifdef OWN_CURSES
  303.   doupdate();       /* und virtuellen Bildschirm in physikalischen uebertragen */
  304. #endif
  305. }
  306.  
  307. /*****************************************************************************
  308. *
  309. *  Funktion       Text und Cursor eine Zeile runter (do_z_runter)
  310. *  --------
  311. *
  312. *  Beschreibung : Der Text wird mitsamt Cursor um eine Zeile nach unten
  313. *                 bewegt.
  314. *
  315. *****************************************************************************/
  316.  
  317. void do_z_runter()
  318. {
  319.   /* *** interne Daten und Initialisierung *** */
  320.   int   i=0;      /* Zaehler fuer Wiederholungen */
  321.   short int hilf; /* Zum Einlesen einer Tastenkombination */
  322.  
  323.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  324.   do                             /* Taste gedrueckt ist. */
  325.     i++;
  326.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  327.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  328.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  329.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  330.  
  331.   if(akt_winp->maxline >= 0 && akt_winp->ws_line > 0)
  332.   { /* Falls Text nicht leer und noch nicht die erste Textzeile zu sehen ist, */
  333.     if(i==1) /* Nur einmel ? */
  334.     {
  335.       akt_winp->ws_line--; /* Nummer der ersten sichtbaren Zeile dekrementieren */
  336.       text_down(0);        /* Text ab Zeile 0 (ganzes Fenster) um 1 nach unten  */
  337.       if(akt_winp->textline >= akt_winp->ws_line + akt_winp->dy)
  338.     up(); /* Stand Cursor in letzter Schirmzeile, Cursor 1 Zeile hoch */
  339.       setz_cursor(W_AKT);        /* Cursor an richtige Position */
  340.     }
  341.     else /* mehrere Wiederholungen */
  342.     {
  343.       /* Fensterinhalt scrollen. Falls zuweit, dann letzte Zeile anzeigen */
  344.       if((akt_winp->ws_line -= i) < 0)
  345.     akt_winp->ws_line = 0;
  346.       /* Ist der Cursor aus dem Fenster gerutscht, dann wird er */
  347.       /* in die letzte Fensterzeile gestellt. Das kann nicht    */
  348.       /* hinter dem Textende sein, da er sonst nicht aus dem    */
  349.       /* Fenster gerutscht waere.                               */
  350.       if(akt_winp->textline >= akt_winp->ws_line+akt_winp->dy)
  351.     gotox(akt_winp->ws_line+akt_winp->dy-1);
  352.       show_win(W_AKT); /* Fensterinhalt darstellen */
  353.       setz_cursor(W_AKT); /* Cursor an richtige Position stellen */
  354.     }
  355.   }
  356. }
  357.  
  358. /*****************************************************************************
  359. *
  360. *  Funktion       Text und Cursor eine Zeile hoch (do_z_hoch)
  361. *  --------
  362. *
  363. *  Beschreibung : Der Text wird mitsamt Cursor um eine Zeile nach oben
  364. *                 bewegt.
  365. *
  366. *****************************************************************************/
  367.  
  368. void do_z_hoch()
  369. {
  370.   /* *** interne Daten und Initialisierung *** */
  371.   int   i=0;      /* Zaehler fuer Wiederholungen */
  372.   short int hilf; /* Zum Einlesen einer Tastenkombination */
  373.  
  374.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  375.   do                             /* Taste gedrueckt ist. */
  376.     i++;
  377.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  378.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  379.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  380.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  381.  
  382.   if(akt_winp->ws_line < akt_winp->maxline)
  383.   { /* Wenn noch nicht die letzte Textzeile zu sehen ist, */
  384.     if(i==1) /* Nur einmel ? */
  385.     {
  386.       akt_winp->ws_line++; /* dann Nummer der ersten sichtbaren Zeile erhoehen */
  387.       text_up(0);          /* gesamten Fenstertext um 1 Zeile nach oben */
  388.       if(akt_winp->textline < akt_winp->ws_line) /* Falls Cursor in oberster */
  389.     down();            /* Zeile, dann Cursor um 1 Zeile nach unten bewegen */
  390.       setz_cursor(W_AKT);       /* Cursor an richtige Position setzen */
  391.     }
  392.     else /* mehrere Wiederholungen */
  393.     {
  394.       /* Fensterinhalt scrollen. Falls zuweit, dann letzte Zeile anzeigen */
  395.       if((akt_winp->ws_line += i) > akt_winp->maxline)
  396.     akt_winp->ws_line = akt_winp->maxline;
  397.       /* Ist der Cursor aus dem Fenster gerutscht, dann wird er */
  398.       /* in die erste Fensterzeile gestellt.                    */
  399.       if(akt_winp->textline < akt_winp->ws_line)
  400.     gotox(akt_winp->ws_line);
  401.       show_win(W_AKT); /* Fensterinhalt darstellen */
  402.       setz_cursor(W_AKT); /* Cursor an richtige Position stellen */
  403.     }
  404.   }
  405. }
  406.  
  407. /*****************************************************************************
  408. *
  409. *  Funktion       aktuelle Zeile in Fenstermitte (do_z_mitte)
  410. *  --------
  411. *
  412. *  Beschreibung : Die aktuelle Zeile wird in die Fenstermitte bewegt.
  413. *
  414. *****************************************************************************/
  415.  
  416. void do_z_mitte()
  417. {
  418.   /* Erste sichtbare Zeile wird die, die einen halben Bildschirm (dy/2)  */
  419.   /* ueber der aktuellen Zeile liegt. Sollte dadurch ws_line kleiner als */
  420.   /* 0 werden (textline zu klein), wird die erster Textzeile zur ersten  */
  421.   /* sichtbaren Zeile gemacht */
  422.   if((akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2)<0)
  423.     akt_winp->ws_line = 0;
  424.   show_win(W_AKT); /* Fensterinhalt anzeigen */
  425. }
  426.  
  427. /*****************************************************************************
  428. *
  429. *  Funktion       aktuelle Zeile an Fensterende (do_z_unten)
  430. *  --------
  431. *
  432. *  Beschreibung : Die aktuelle Zeile wird an das Fensterende bewegt.
  433. *
  434. *****************************************************************************/
  435.  
  436. void do_z_unten()
  437. {
  438.   /* Erste sichtbare Zeile wird aktuelle Zeile abzueglich einer Bild-   */
  439.   /* schirmlaenge. Ist das resultat kleiner 0 (textline zu klein), wird */
  440.   /* die erste Textzeile zur ersten sichtbaren Zeile */
  441.   if((akt_winp->ws_line = akt_winp->textline - akt_winp->dy + 1)<0)
  442.     akt_winp->ws_line = 0;
  443.   show_win(W_AKT); /* Fensterinhalt darstellen */
  444. }
  445.  
  446. /*****************************************************************************
  447. *
  448. *  Funktion       aktuelle Zeile an Fensteranfang (do_z_oben)
  449. *  --------
  450. *
  451. *  Beschreibung : Die aktuelle Zeile wird an den Fensteranfang bewegt.
  452. *
  453. *****************************************************************************/
  454.  
  455. void do_z_oben()
  456. {
  457.   if(akt_winp->textline >=0) /* Falls Text nicht leer, */
  458.   {
  459.     akt_winp->ws_line = akt_winp->textline; /* wird aktuelle Zeile zur */
  460.     show_win(W_AKT); /* erster sichtbaren, Fensterinhalt wird neu dargestellt */
  461.   }
  462. }
  463.  
  464. /*****************************************************************************
  465. *
  466. *  Funktion       Gehe an Zeilenanfang (do_bol)
  467. *  --------
  468. *
  469. *  Beschreibung : Der Cursor wird an den Zeilenanfang bewegt.
  470. *
  471. *****************************************************************************/
  472.  
  473. void do_bol()
  474. {
  475.   bol();                    /* Cursor an Zeilenanfang stellen */
  476.   if(akt_winp->ws_col)      /* Wenn erste Spalte nicht auf Bildschirm, */
  477.   {
  478.     akt_winp->ws_col = 0;   /* Dann erste Spalte zur ersten sichtbaren */
  479.     show_win(W_AKT);             /* machen, Fensterinhalt neu darstellen    */
  480.   }
  481.   setz_cursor(W_AKT);  /* Cursor an richtige Position */
  482. }
  483.  
  484. /*****************************************************************************
  485. *
  486. *  Funktion       Gehe an Zeilenende (do_eol)
  487. *  --------
  488. *
  489. *  Beschreibung : Der Cursor wird an das Zeilenende bewegt.
  490. *
  491. *****************************************************************************/
  492.  
  493. void do_eol()
  494. {
  495.   eol(); /* Cursor intern ans Zeilenende setzen */
  496.   /* Falls Cursorposition rechts vom Bildschirm oder */
  497.   if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol
  498.   || akt_winp->ws_col > akt_winp->screencol) /* links vom Bildschirm */
  499.   { /* dann Position anpassen */
  500.     /* Falls screencol < dx, dann kann erste Spalte dargestellt werden. */
  501.     /* Sonst wird die aktuelle Spalte zur letzten sichtbaren Spalte. */
  502.     akt_winp->ws_col = (akt_winp->screencol < akt_winp->dx) ?
  503.     0 : akt_winp->screencol - akt_winp->dx + 1;
  504.     show_win(W_AKT); /* Fensterinhalt darstellen */
  505.   }
  506.   setz_cursor(W_AKT); /* Cursor an richtige Position setzen */
  507. }
  508.  
  509. /*****************************************************************************
  510. *
  511. *  Funktion       Gehe halbe Seite hoch (do_halfup)
  512. *  --------
  513. *
  514. *  Beschreibung : Der Cursor wird um eine halbe Seite nach oben bewegt.
  515. *
  516. *****************************************************************************/
  517.  
  518. void do_halfup()
  519. {
  520.   /* *** interne Daten *** */
  521.   register int hilf;   /* zum Einlesen einer Tastenkombination */
  522.  
  523.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  524.   do                             /* Taste gedrueckt ist. */
  525.     if((akt_winp->ws_line -= half_up()) < 0) /* Cursor hochbewegen und */
  526.       akt_winp->ws_line = 0; /* neuen Fensterstart berechnen */
  527.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  528.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  529.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  530.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  531.   show_win(W_AKT);                 /* Text im Fenster neu anzeigen     */
  532.   setz_cursor(W_AKT);               /* Cursor an richtige Position setzen */
  533. }
  534.  
  535. /*****************************************************************************
  536. *
  537. *  Funktion       Gehe halbe Seite runter (do_halfdn)
  538. *  --------
  539. *
  540. *  Beschreibung : Der interne Cursor wird um eine halbe Seite nach unten bewegt.
  541. *                 Dann wird die Fensterposition angepasst und der
  542. *                 Fensterinhalt erneut dargestellt. Steht der Cursor in der
  543. *                 letzten Textzeile, so wird diese in die Bildschirmmitte
  544. *                 plaziert.
  545. *
  546. *****************************************************************************/
  547.  
  548. void do_halfdn()
  549. {
  550.   /* *** interne Daten *** */
  551.   register int hilf;   /* Zum Einlesen einer Tastenkombination */
  552.  
  553.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  554.   do                             /* Taste gedrueckt ist. */
  555.     akt_winp->ws_line += half_down(); /* Cursor und Fensterstart anpassen */
  556.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls noch mal der */
  557.   /* gleiche Code im Tastaturpuffer, Aktion wiederholen */
  558.   lastcode = hilf;   /* letzte Tastenkombination merken */
  559.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll wieder auf Taste warten */
  560.   show_win(W_AKT);                  /* Text im Fenster neu anzeigen     */
  561.   setz_cursor(W_AKT);                /* Cursor an richtige Position setzen */
  562. }
  563.  
  564. /*****************************************************************************
  565. *
  566. *  Funktion       loesche aktuelles Zeichen (do_delete)
  567. *  --------
  568. *
  569. *  Beschreibung : Das unter dem Cursor stehende Zeichen wird geloescht.
  570. *
  571. *****************************************************************************/
  572.  
  573. void do_delete()
  574. {
  575.   if (delete())   /* Zeichen, auf dem der Cursor steht loeschen */
  576.   {               /* klappt das, wird die aktuelle Zeile neu angezeigt */
  577.     lineout(akt_winp->textline-akt_winp->ws_line);
  578.     setz_cursor(W_AKT); /* und der Cursor an die richtige Position gesetzt */
  579.   }
  580. }
  581.  
  582. /*****************************************************************************
  583. *
  584. *  Funktion       loesche Zeichen links (do_backspace)
  585. *  --------
  586. *
  587. *  Beschreibung : Das links vom Cursor stehende Zeichen wird geloescht.
  588. *
  589. *****************************************************************************/
  590.  
  591. void do_backspace()
  592. {
  593.   if(backspace())  /* Das Zeichen links vom Cursor wird geloescht */
  594.   {                /* Klappt das, wird gecheckt, ob Cursor links vom Schirm */
  595.     if(akt_winp->screencol < akt_winp->ws_col)
  596.       text_right(); /* Falls ja, Text um eine Spalte nach rechts bewegen */
  597.     lineout(akt_winp->textline-akt_winp->ws_line); /* Zeile neu anzeigen */
  598.     setz_cursor(W_AKT); /* cursor an richtige Position setzen */
  599.   }
  600.   else /* es ging nicht nach links. Das ist sicher, da delete in backspace */
  601.   {    /* nur dann einen Fehler liefert, wenn Abschlußnull gelöscht werden */
  602.        /* soll, aber das kann hier nicht auftreten. */
  603.     if (akt_winp->textline > 0) /* geht es eine Zeile hoch ? */
  604.     {
  605.       do_up();
  606.       do_join();
  607.     }
  608.   }
  609. }
  610.  
  611. /*****************************************************************************
  612. *
  613. *  Funktion       Cursor an Bildschirmanfang (do_home)
  614. *  --------
  615. *
  616. *  Beschreibung : Der Cursor wird in die erste Zeile des Bildschirms
  617. *                 bewegt.
  618. *
  619. *****************************************************************************/
  620.  
  621. void do_home()
  622. {
  623.   gotox(akt_winp->ws_line); /* Cursor intern auf erste Bildschirmzeile setzen */
  624.   setz_cursor(W_AKT);            /* Cursor auf Bildschirm plazieren */
  625. }
  626.  
  627.  
  628. /*****************************************************************************
  629. *
  630. *  Funktion       Cursor an Bildschirmende (do_nothome)
  631. *  --------
  632. *
  633. *  Beschreibung : Der Cursor wird in die letzte Zeile des Bildschirms
  634. *                 bewegt.
  635. *
  636. *****************************************************************************/
  637.  
  638. void do_nothome()
  639. {
  640.   gotox(akt_winp->ws_line + akt_winp->dy -1); /* Cursor in letzte Bild- */
  641.   setz_cursor(W_AKT); /* schirmzeile. Anschliessend Cursor auf Schirm plazieren */
  642. }
  643.  
  644. /*****************************************************************************
  645. *
  646. *  Funktion       Underlinemodus toggeln (do_underline)
  647. *  --------
  648. *
  649. *  Beschreibung : Die unterstrichene Schriftart wird aktiviert/deaktiviert.
  650. *
  651. *****************************************************************************/
  652.  
  653. void do_underline()
  654. {
  655.   akt_winp->underflag ^= TRUE;  /* Flag fuer Unterstreichung togglen */
  656.   setz_cursor(W_AKT);                /* Kopfzeile aktualisieren */
  657. }
  658.  
  659. /*****************************************************************************
  660. *
  661. *  Funktion       Schreibmodus toggeln (do_insovr)
  662. *  --------
  663. *
  664. *  Beschreibung : Der Schreibmodus wird invertiert.
  665. *
  666. *****************************************************************************/
  667.  
  668. void do_insovr()
  669. {
  670.   akt_winp->insflag ^= TRUE;    /* Insertflag togglen */
  671.   setz_cursor(W_AKT);                /* Kopfzeile aktualisieren */
  672. }
  673.